package com.ruan.controller;


import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.google.gson.Gson;
import com.ruan.common.Code;
import com.ruan.common.R;
import com.ruan.common.Result;
import com.ruan.mapper.EmployeeMapper;
import com.ruan.mapper.PositionMapper;
import com.ruan.pojo.Employee;
import com.ruan.pojo.Position;
import com.ruan.pojoExt.PositionExt;
import com.ruan.service.EmployeeService;
import com.ruan.service.PositionService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Slf4j
@RestController
@RequestMapping("/position")
public class PositionController {
    @Autowired
    private PositionService positionService;
    @Autowired
    private EmployeeService employeeService;
    @Autowired
    private EmployeeMapper employeeMapper;
    @Autowired
    private PositionMapper positionMapper;

    //部门信息分页查询
    //创建一个controller方法，接收页面发送的请求并且接收参数（page,pageSize,name）
    @GetMapping("/page")
    public R<Page> page(int page, int pageSize, Long departmentId1, String Pname, String Dname){//第三个参数 name 可能是从前端的用户输入或者页面的搜索框中获取的
//        log.info("page = {},pageSize = {}, name = {}",page,pageSize,Pname);

        Page<Position> pageInfo = new Page<>(page,pageSize);
        Page<PositionExt> positionExtPage = new Page<>();//封装

        LambdaQueryWrapper<Position> queryWrapper = new LambdaQueryWrapper();
//查看部门的相关职位
//        System.out.println("传来的部门id是"+departmentId1);
//        queryWrapper.eq(Position::getDepartmentId,departmentId1);
//搜索框输入的是职位名字。。
        queryWrapper.like(StringUtils.isNotEmpty(Pname), Position::getPname,Pname);
        //添加排序条件
        queryWrapper.orderByDesc();//Position::getUpdateTime
        //执行查询                   // 条件构造器
        positionService.page(pageInfo,queryWrapper);
        //page方法已经已经继承了IService,已经提供了分页查询方法，只需要把Page对象和queryWrapper对象构造好，传给他，自己就会进行分页查询
        //条件构造器传进去之后，不需要去返回，因为把pageInfo传进去之后，在page内部，就会把查出来的数据进行封装，最终封装给page里的records,total。。
        BeanUtils.copyProperties(pageInfo,positionExtPage,"records");//从pageInfo一个一个拷贝属性到positionExtPage上(除了records)
//处理
        List<Position> records = pageInfo.getRecords();
        List<PositionExt> list = records.stream().map((item) -> {//item:遍历出来的每一个项目对象
            PositionExt positionExt = new PositionExt();//只有PositionExt符合项目管理页面的要求，所以new一个出来,进行填充
            BeanUtils.copyProperties(item,positionExt);//先填充入position的普通属性
//            Long departmentId = item.getDepartmentId();//拿到了每个职位所对应的部门id
            Long employeeId = item.getEmployeeId();//拿到了每个职位所对应的上级的id
            Long positionId = item.getId();//拿每个职位id和部门的id到员工表查询当前该职位的任职数量
            Integer maxPositions = item.getMaxPositions();

            //根据positionId查员工(表)(需要注入positionService)，把positionName拿到
//            Department department = departmentService.getById(departmentId);
            Employee employee = employeeService.getById(employeeId);
//            Long count = Long.valueOf(employeeMapper.selectCount(new QueryWrapper<Employee>()
//                 .eq("position_id", positionId)));
//            .eq("department_id", departmentId)
//            System.out.println("该职位当前任职数："+count);
//            if(count != null){//能查到职位数
//                positionExt.setCurrentNum(Math.toIntExact(count));//填充入position没有的currentNum属性
//            }
//            if(count>=maxPositions){
//                positionExt.setStatus(0);//已满额
//                System.out.println("已满额?"+positionExt.getStatus());
//            }else {
//                positionExt.setStatus(1);//未满额
//                System.out.println("未满额?"+positionExt.getStatus());
//            }

//            if(department != null){//能查到部门
//                String departmentName = department.getName();
//                positionExt.setDepartmentName(departmentName);//填充入position没有的departmentName属性
//            }
//            if(employee != null){//能查到该职位的上级
//                String employeeName = employee.getName();
//                positionExt.setEmployeeName(employeeName);//填充入position没有的employeeName属性
//            }

            positionService.updateById(positionExt);//重点是把status更新到数据库里面去
            return positionExt;//填充完新键的positionExt之后，返回，把遍历的这些positionExt对象搜集起来后
        }).collect(Collectors.toList());//就转成集合了，赋给List<positionExt> list
//        System.out.println("list里有了什么"+list);
        positionExtPage.setRecords(list);//list获得了改造过后的positionExt集合之后，被用来设置page对象的Records属性
        return R.success(positionExtPage);
    }
    @GetMapping("/getPosition")
    public Result getPosition(){
        try {
            List<Position> positionList = positionService.getPosition();
//            System.out.println("查看职位信息："+positionList);
            return new Result(Code.SELECT_OK,positionList);
        } catch (Exception e) {
            e.printStackTrace();
            return new Result(Code.SELECT_ERR,"查询职位失败！");
        }

    }
    //@RequestBody用于指示在HTTP请求中传递的数据应该绑定到方法参数。它通常用于接收请求体中的数据（如JSON或XML），并将其映射到后端的对象。
    //根据id修改员工信息
    @PutMapping
    public R<String> update(HttpServletRequest request, @RequestBody Position position){
//‘@RequestBody’注释表明‘Position’对象将从请求体中反序列化，通常采用JSON或XML格式。
//        log.info("修改职位信息：："+position.toString());

        long id = Thread.currentThread().getId();
//        log.info("当前线程id为：{}",id);
        positionService.updateById(position);//updateById继承自父接口IService(由mybatis-plus提供)
        return R.success("职位信息修改成功");
    }
    //employee.js要用
    //查询该部门下的所有职位
//    @GetMapping("/getPname/{departmentId}")//   路径变量//说明id变量是在整个请求路径里
//    public R<Object> getAllPositionNameByDepartmentId(@PathVariable String departmentId){
//        log.info("根据departmentId查询职位名,departmentId是"+departmentId);
////        System.out.println("根据dname查询部门id,dname是"+dname);
//        LambdaQueryWrapper<Position> queryWrapper = new LambdaQueryWrapper<>();
//        Long did = Long.valueOf(departmentId);
//        queryWrapper.select(Position::getId,Position::getPname).eq(Position::getDepartmentId,did);
//        List<Position> positionList = positionMapper.selectList(queryWrapper); // 一个部门有一堆职位
//        System.out.println("职位列表有了吗"+positionList);
//
////        List<String> positionNames = new ArrayList<>();
////把这个放到前端来处理，因为前端要用到
//// <el-option v-for="position in positionsName" :key="position.pname"
//// :label="position.pname" :value="position.pname"></el-option>
////        for(Position position : positionList) {
////            String positionName = position.getPname();
////            positionNames.add(positionName);
////        }
//
//// 现在positionNames集合中包含了positionList中每个position的名字
//        System.out.println("职位名都有什么");//应该有多个。。。。。。。？？？？？
//        System.out.println(positionList);
//        if(positionList.size()>0){//部门的职位能查得出来才返回
//            return R.success(positionList);//department对象在R里转成了json
//        }
//        return R.error("没有查询到这个部门的职位");
//    }

    //--------------------------------------------------
    //初始化页面时把要变灰的职位名disabledPositionName传到前端
    @GetMapping("/getDisabledPosition")//   路径变量//说明id变量是在整个请求路径里
    public List<String> getDisabledPositionByPositionName() {
        // 根据部门id和职位id查询并计算position表的记录的条数(实现：这个部门的这种职位的数量够了吗)
        LambdaQueryWrapper<Position> queryWrapper = new LambdaQueryWrapper<>();//所有的职位
        List<Position> positions = positionMapper.selectList(queryWrapper);//拿到职位表的所有职位
//        queryWrapper.eq(Position::getDepartmentId, department.getId());
//        List<Position> positions = positionMapper.selectList(queryWrapper); // 一个部门有一堆职位
//        System.out.println("positions有什么" + positions);
//        LambdaQueryWrapper<Position> queryWrapper3 = new LambdaQueryWrapper<>();
//        queryWrapper1.eq(Position::getDepartmentId, department.getId())//根据部门id和职位名查该部门下的某个职位
//                .eq(Position::getPname, pname);
//        Position position = positionService.getOne(queryWrapper1);//查出某部门的某个职位了
//        System.out.println("positions是什么" + positions);
        List<String> disabledPositionName = new ArrayList<>();//把要灰色显示的职位Name存起来
        for (Position position : positions) {//positions是所有职位的集合///这个部门下的
            String positionName = position.getPname();//把所有职位名get到，后面再做筛选
            Integer maxCount = position.getMaxPositions();//获取这个职位的最大限制数量，每遍历一次就有一个最大数量
            Integer currentStatus = position.getStatus();
            //目前这个职位的数量
            // Integer currentCount = positionCountMap.getOrDefault(positionId, 0);
//            LambdaQueryWrapper<Position> queryWrapper1 = new LambdaQueryWrapper<>();//一种职位
//            queryWrapper1.eq(Position::getDepartmentId, department.getId())//department.getId()是循环外提供的
//                    .eq(Position::getPname, positionName);//positionName是循环内提供的.selectCount
            LambdaQueryWrapper<Employee> queryWrapper1 = new LambdaQueryWrapper<>();
            queryWrapper1.eq(Employee::getPositionId, position.getId());

            Integer currentCount = Math.toIntExact(employeeService.count(queryWrapper1));
//            System.out.println("这个职位的最大数量是："+maxCount);
//            System.out.println("目前这个(职位名是唯一的)职位的数量：" + currentCount);
//            if (currentCount == maxCount-1) {//
//                System.out.println("默认状态是1(启用):"+position.getStatus());
//                position.setStatus(0);
//                System.out.println("设职位状态为0(禁用):"+position.getStatus());
//            }
//            System.out.println("当前职位状态是"+currentStatus);// || currentStatus==0
            if (currentCount >= maxCount) {//这个职位人超出数量限制了，或者手动更改职位状态
                disabledPositionName.add(positionName);
//                System.out.println("默认状态是1(启用):"+position.getStatus());
//                position.setStatus(0);
//                System.out.println("设职位状态为0(禁用):"+position.getStatus());
            }
        }//可以创建一个包含你想要返回的多个值的对象，然后从方法中返回这个对象

        return disabledPositionName;//返回到前端，让这些职位变灰色
    }
//------------------------------------------------------------

    @GetMapping("/getCurrentCountAndMaxPosition/{pid}")
    public R<String> getCurrentCountAndMaxPosition(@PathVariable Long pid){
//        System.out.println("职位id是："+pid);
        LambdaQueryWrapper<Position> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Position::getId, pid);
        Position position = positionService.getOne(queryWrapper);//查到前端下拉框选中的这个职位，找他的currentCount和maxCount
        LambdaQueryWrapper<Employee> queryWrapper1 = new LambdaQueryWrapper<>();
        queryWrapper1.eq(Employee::getPositionId, position.getId());
        Integer currentCount = Math.toIntExact(employeeService.count(queryWrapper1));
        Integer maxCount = position.getMaxPositions();

        Map<String, String> resultMap = new HashMap<>();
        resultMap.put("currentCount", String.valueOf(currentCount));
        resultMap.put("maxCount", String.valueOf(maxCount));
//        System.out.println("resultMap是什么"+resultMap);
//        if(resultMap!=null){//查出来才返回R.success(resultMap);resultMap
//         System.out.println("成功了吗111");
        // 使用 Gson 库将 Map 转换为 JSON 字符串
        String resultMapJsonData = new Gson().toJson(resultMap);
//        System.out.println("转换后："+resultMapJsonData);
        return R.success(resultMapJsonData);
//        }
//        return "sss";
//        return R.error("没有查询到这个职位");
    }


    @GetMapping("/{Id}")//   路径变量//说明id变量是在整个请求路径里
    public R<Object> queryPositionById(@PathVariable Long Id){
//        log.info("根据Id查询职位,departmentId是"+Id);
        LambdaQueryWrapper<Position> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Position::getId, Id); // 添加查询条件
        Position position = positionMapper.selectOne(queryWrapper); // 使用mapper执行查询
//        System.out.println("职位是："+position);
        if(position!=null){//查出来才返回
            return R.success(position);//department对象在R里转成了json
        }
        return R.error("没有查询到这个职位");
    }

    //新增职位
    @PostMapping
    public R<String> save(@RequestBody Position position){
//        log.info("新增职位，职位信息：{}",position.toString());
        positionService.save(position);//把这个对象存进去
//save方法继承自mybatis-plus的父接口IService（看看application.yml文件）,可以直接调用
        return R.success("新增职位成功");
    }

}
